package com.lancoo.edu.platform.operation.commons.dto;

import javax.servlet.http.HttpServletResponse;

/**
 * 统一响应结果工厂
 * @param <T>
 * @author pky
 */
public class BaseResultFactory<T> {

    private static BaseResultFactory<Object> baseResultFactory;

    private BaseResultFactory() {

    }

    private static HttpServletResponse response;

    /**
     * 单例模式获取 BaseResultFactory 实例
     * @param response 响应
     * @return 工程
     */
    public static <T> BaseResultFactory<Object> getInstance(HttpServletResponse response) {
        if(baseResultFactory == null) {
            synchronized (BaseResultFactory.class) {
                if(baseResultFactory == null) {
                    baseResultFactory = new BaseResultFactory<>();
                }
            }
        }
        BaseResultFactory.response = response;
        // baseResultFactory.initResponse();
        return baseResultFactory;
    }

    /**
     * 构建固定响应码和说明成功结果无数据工厂
     * @return 固定响应码和说明成功结果
     */
    public Result<T> build() {
        return new Result<>();
    }

    /**
     * 构建无数据固定响应码工厂
     * @param msg 说明
     * @return 无数据固定响应码结果
     */
    public Result<T> build(String msg) {
        return new Result<>(msg);
    }


    /**
     * 构建无数据工厂
     * @param code 状态码
     * @param msg 说明
     * @return 无数据结果
     */
    public BaseResult build(int code, String msg) {
        return new Result<>(code, msg);
    }

    /**
     * 构建成功固定说明工厂
     * @param attribute 具体数据实体
     * @return 单笔成功固定说明结果
     */
    public Result<T> build(T attribute) {
        return new Result<>(attribute);
    }


    /**
     * 构建成功带说明工厂
     * @param msg 说明
     * @param attribute 数据实体
     * @return 单笔成功带说明数据结果
     */
    public Result<T> build(String msg, T attribute) {
        return new Result<>(msg, attribute);
    }

    /**
     * 构建数据工厂
     * @param code 状态码
     * @param msg 说明
     * @param attribute 具体数据实体
     * @return 单笔数据结果
     */
    public Result<T> build(int code, String msg, T attribute) {
        return new Result<>(code, msg, attribute);
    }

    /**
     * 构建分页数据工厂
     * @param attribute 具体数据实体
     * @return 单笔数据结果
     */
    public PageResult<T> build(long total, T attribute) {
        return new PageResult<>(total, attribute);
    }


    /**
     * 构建系统健康数据工厂
     * @param error 总条数
     * @param msg 说明
     * @param attribute 具体数据
     * @return 系统健康结果
     */
    public HealthResult<T> buildHealth(int error, String msg,  T attribute) {
        return new HealthResult<>(error, msg, attribute);
    }
    /**
     * 构建系统健康数据工厂
     * @param error 总条数
     * @param msg 说明
     * @return 系统健康结果
     */
    public HealthResult<T> buildHealth(int error, String msg) {
        return new HealthResult<>(error, msg);
    }
    /**
     * 构建系统健康数据工厂
     * @param attribute 具体数据
     * @return 系统健康结果
     */
    public HealthResult<T> buildHealth(T attribute) {
        return new HealthResult<>(attribute);
    }

    /**
     * 构建旧版应用桌面数据工厂 --无数据
     * @return 无数据不固定响应码和响应说明结果
     */
    public ResultAppMgr<T> buildAppMgr(int code, String msg){return new ResultAppMgr<>(code,msg);}

    /**
     * 构建旧版应用桌面数据工厂
     * @param attribute 具体数据
     * @return 无数据固定响应码结果
     */
    public ResultAppMgr<T> buildAppMgr(T attribute){return new ResultAppMgr<>(attribute);}

    /**
     * 设置响应头
     */
    private void initResponse(){
        response.setHeader("Content-Type", "application/vnd.api+json");
        response.setCharacterEncoding("UTF-8");
        response.addHeader("X-Frame-Options", "DENY");
        response.addHeader("Cache-Control", "no-cache, no-store, must-revalidate, max-age=0");
        response.addHeader("Cache-Control", "no-cache='set-cookie'");
        response.addHeader("Pragma", "no-cache");
    }

}